[−][src]Trait protocol::Unravel

pub trait Unravel<C: ?Sized> {
    type Finalize: Future<C, Ok = (), Error = <Self::Target as Future<C>>::Error>;
    type Target: Future<C, Ok = Self::Finalize>;
    fn unravel(self) -> Self::Target;
}

Associated Types

`type Finalize: Future<C, Ok = (), Error = <Self::Target as Future<C>>::Error>`

`type Target: Future<C, Ok = Self::Finalize>`

Loading content...

Required methods

`fn unravel(self) -> Self::Target`

Loading content...

Implementations on Foreign Types

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 2]> + Fork<T> + Unpin> Unravel<C> for [T; 2] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 2]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0002Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 3]> + Fork<T> + Unpin> Unravel<C> for [T; 3] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 3]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0003Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 4]> + Fork<T> + Unpin> Unravel<C> for [T; 4] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 4]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0004Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 5]> + Fork<T> + Unpin> Unravel<C> for [T; 5] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 5]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0005Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 6]> + Fork<T> + Unpin> Unravel<C> for [T; 6] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 6]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0006Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 7]> + Fork<T> + Unpin> Unravel<C> for [T; 7] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 7]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0007Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 8]> + Fork<T> + Unpin> Unravel<C> for [T; 8] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 8]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0008Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 9]> + Fork<T> + Unpin> Unravel<C> for [T; 9] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 9]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0009Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 10]> + Fork<T> + Unpin> Unravel<C> for [T; 10] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 10]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0010Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 11]> + Fork<T> + Unpin> Unravel<C> for [T; 11] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 11]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0011Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 12]> + Fork<T> + Unpin> Unravel<C> for [T; 12] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 12]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0012Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 13]> + Fork<T> + Unpin> Unravel<C> for [T; 13] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 13]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0013Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 14]> + Fork<T> + Unpin> Unravel<C> for [T; 14] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 14]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0014Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 15]> + Fork<T> + Unpin> Unravel<C> for [T; 15] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 15]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0015Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 16]> + Fork<T> + Unpin> Unravel<C> for [T; 16] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 16]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0016Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 17]> + Fork<T> + Unpin> Unravel<C> for [T; 17] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 17]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0017Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 18]> + Fork<T> + Unpin> Unravel<C> for [T; 18] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 18]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0018Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 19]> + Fork<T> + Unpin> Unravel<C> for [T; 19] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 19]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0019Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 20]> + Fork<T> + Unpin> Unravel<C> for [T; 20] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 20]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0020Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 21]> + Fork<T> + Unpin> Unravel<C> for [T; 21] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 21]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0021Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 22]> + Fork<T> + Unpin> Unravel<C> for [T; 22] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 22]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0022Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 23]> + Fork<T> + Unpin> Unravel<C> for [T; 23] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 23]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0023Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 24]> + Fork<T> + Unpin> Unravel<C> for [T; 24] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 24]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0024Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 25]> + Fork<T> + Unpin> Unravel<C> for [T; 25] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 25]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0025Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 26]> + Fork<T> + Unpin> Unravel<C> for [T; 26] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 26]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0026Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 27]> + Fork<T> + Unpin> Unravel<C> for [T; 27] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 27]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0027Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 28]> + Fork<T> + Unpin> Unravel<C> for [T; 28] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 28]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0028Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 29]> + Fork<T> + Unpin> Unravel<C> for [T; 29] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 29]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0029Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 30]> + Fork<T> + Unpin> Unravel<C> for [T; 30] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 30]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0030Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 31]> + Fork<T> + Unpin> Unravel<C> for [T; 31] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 31]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0031Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 32]> + Fork<T> + Unpin> Unravel<C> for [T; 32] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 32]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0032Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 64]> + Fork<T> + Unpin> Unravel<C> for [T; 64] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 64]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0064Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 128]> + Fork<T> + Unpin> Unravel<C> for [T; 128] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 128]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0128Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 256]> + Fork<T> + Unpin> Unravel<C> for [T; 256] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 256]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0256Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 512]> + Fork<T> + Unpin> Unravel<C> for [T; 512] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 512]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0512Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 1024]> + Fork<T> + Unpin> Unravel<C> for [T; 1024] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 1024]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array1024Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 2048]> + Fork<T> + Unpin> Unravel<C> for [T; 2048] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 2048]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array2048Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 4096]> + Fork<T> + Unpin> Unravel<C> for [T; 4096] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 4096]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array4096Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 8192]> + Fork<T> + Unpin> Unravel<C> for [T; 8192] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 8192]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array8192Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T: Unpin, C: ?Sized + Write<<C as Dispatch<T>>::Handle> + Fork<T> + Unpin> Unravel<C> for [T; 1] where C::Future: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin,` [src]

`type Finalize = MapErr<C::Finalize, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0001Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T: Unpin, C: ?Sized + Write<Option<<C as Dispatch<T>>::Handle>> + Fork<T> + Unpin> Unravel<C> for Option<T> where C::Future: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin,` [src]

type Finalize = Either<MapErr<C::Finalize, fn(_: <C::Finalize as Future<C>>::Error) -> OptionUnravelError<<C as Write<Option<<C as Dispatch<T>>::Handle>>>::Error, <<C as Fork<T>>::Future as Future<C>>::Error, <<C as Fork<T>>::Target as Future<C>>::Error, <<C as Fork<T>>::Finalize as Future<C>>::Error>>, Ready<(), OptionUnravelError<<C as Write<Option<<C as Dispatch<T>>::Handle>>>::Error, <<C as Fork<T>>::Future as Future<C>>::Error, <<C as Fork<T>>::Target as Future<C>>::Error, <<C as Fork<T>>::Finalize as Future<C>>::Error>>>

`type Target = OptionUnravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for u8`[src]

`type Finalize = Ready<(), C::Error>`

`type Target = PrimitiveUnravel<Self>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for u16`[src]

`type Finalize = Ready<(), C::Error>`

`type Target = PrimitiveUnravel<Self>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for u32`[src]

`type Finalize = Ready<(), C::Error>`

`type Target = PrimitiveUnravel<Self>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for u64`[src]

`type Finalize = Ready<(), C::Error>`

`type Target = PrimitiveUnravel<Self>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for u128`[src]

`type Finalize = Ready<(), C::Error>`

`type Target = PrimitiveUnravel<Self>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for i8`[src]

`type Finalize = Ready<(), C::Error>`

`type Target = PrimitiveUnravel<Self>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for i16`[src]

`type Finalize = Ready<(), C::Error>`

`type Target = PrimitiveUnravel<Self>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for i32`[src]

`type Finalize = Ready<(), C::Error>`

`type Target = PrimitiveUnravel<Self>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for i64`[src]

`type Finalize = Ready<(), C::Error>`

`type Target = PrimitiveUnravel<Self>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for i128`[src]

`type Finalize = Ready<(), C::Error>`

`type Target = PrimitiveUnravel<Self>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for f32`[src]

`type Finalize = Ready<(), C::Error>`

`type Target = PrimitiveUnravel<Self>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for f64`[src]

`type Finalize = Ready<(), C::Error>`

`type Target = PrimitiveUnravel<Self>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for bool`[src]

`type Finalize = Ready<(), C::Error>`

`type Target = PrimitiveUnravel<Self>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for char`[src]

`type Finalize = Ready<(), C::Error>`

`type Target = PrimitiveUnravel<Self>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for usize`[src]

`type Finalize = Ready<(), C::Error>`

`type Target = PrimitiveUnravel<Self>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for isize`[src]

`type Finalize = Ready<(), C::Error>`

`type Target = PrimitiveUnravel<Self>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Unpin + Write<Self>> Unravel<C> for String`[src]

`type Finalize = Ready<(), C::Error>`

`type Target = PrimitiveUnravel<Self>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized> Unravel<C> for ()`[src]

`type Finalize = Ready<()>`

`type Target = Ready<Ready<()>>`

`fn unravel(self) -> Self::Target`[src]

`impl<T: Unpin + ?Sized, C: ?Sized> Unravel<C> for PhantomData<T>`[src]

`type Finalize = Ready<()>`

`type Target = Ready<Ready<()>>`

`fn unravel(self) -> Self::Target`[src]

`impl<T: Unpin, C: ?Sized> Unravel<C> for [T; 0]`[src]

`type Finalize = Ready<()>`

`type Target = Ready<Ready<()>>`

`fn unravel(self) -> Self::Target`[src]

`impl<T: Unpin, E: Unpin, C: ?Sized + Write<Result<<C as Dispatch<T>>::Handle, <C as Dispatch<E>>::Handle>> + Fork<T> + Fork<E> + Unpin> Unravel<C> for Result<T, E> where <C as Fork<T>>::Future: Unpin, <C as Fork<E>>::Future: Unpin, <C as Fork<T>>::Target: Unpin, <C as Fork<E>>::Target: Unpin, <C as Fork<T>>::Finalize: Unpin, <C as Fork<E>>::Finalize: Unpin, <C as Dispatch<T>>::Handle: Unpin, <C as Dispatch<E>>::Handle: Unpin,` [src]

type Finalize = Either<MapErr<<C as Fork<T>>::Finalize, fn(_: <<C as Fork<T>>::Finalize as Future<C>>::Error) -> ResultUnravelError<<<C as Fork<T>>::Future as Future<C>>::Error, <<C as Fork<E>>::Future as Future<C>>::Error, <C as Write<Result<<C as Dispatch<T>>::Handle, <C as Dispatch<E>>::Handle>>>::Error, <<C as Fork<T>>::Target as Future<C>>::Error, <<C as Fork<E>>::Target as Future<C>>::Error, <<C as Fork<T>>::Finalize as Future<C>>::Error, <<C as Fork<E>>::Finalize as Future<C>>::Error>>, MapErr<<C as Fork<E>>::Finalize, fn(_: <<C as Fork<E>>::Finalize as Future<C>>::Error) -> ResultUnravelError<<<C as Fork<T>>::Future as Future<C>>::Error, <<C as Fork<E>>::Future as Future<C>>::Error, <C as Write<Result<<C as Dispatch<T>>::Handle, <C as Dispatch<E>>::Handle>>>::Error, <<C as Fork<T>>::Target as Future<C>>::Error, <<C as Fork<E>>::Target as Future<C>>::Error, <<C as Fork<T>>::Finalize as Future<C>>::Error, <<C as Fork<E>>::Finalize as Future<C>>::Error>>>

`type Target = ResultUnravel<T, E, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T: Unpin, U: Unpin, C: ?Sized + Write<(<C as Dispatch<T>>::Handle, <C as Dispatch>::Handle)> + Fork<T> + Fork + Unpin> Unravel<C> for (T, U) where <C as Fork<T>>::Future: Unpin, <C as Fork>::Future: Unpin, <C as Fork<T>>::Target: Unpin, <C as Fork>::Target: Unpin, <C as Fork<T>>::Finalize: Unpin, <C as Fork>::Finalize: Unpin, <C as Dispatch<T>>::Handle: Unpin, <C as Dispatch>::Handle: Unpin,` [src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T>>::Finalize>, Option<<C as Fork>::Finalize>), (T, U)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T>>::Finalize>, Option<<C as Fork>::Finalize>), (T, U)> as Future<C>>::Error) -> Tuple2UnravelError<<C as Write<(<C as Dispatch<T>>::Handle, <C as Dispatch>::Handle)>>::Error, <<C as Fork<T>>::Future as Future<C>>::Error, <<C as Fork>::Future as Future<C>>::Error, <Finalize<C, (T, U)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T>>::Finalize>, Option<<C as Fork>::Finalize>), (T, U)> as Future<C>>::Error>>

`type Target = Tuple2Unravel<T, U, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<<C as Dispatch<T>>::Handle> + Fork<T> + Unpin> Unravel<C> for (T,) where C::Future: Unpin, C::Target: Unpin, C::Finalize: Unpin, C::Handle: Unpin,` [src]

`type Finalize = MapErr<C::Finalize, fn(_: <C::Finalize as Future<C>>::Error) -> FlatUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error>>`

`type Target = FlatUnravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

impl<T0: Unpin, T1: Unpin, T2: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle)> + Fork<T0> + Fork<T2> + Fork<T1> + Unpin> Unravel<C> for (T0, T1, T2) where <C as Fork<T0>>::Future: Unpin, <C as Fork<T0>>::Target: Unpin, <C as Fork<T0>>::Finalize: Unpin, <C as Dispatch<T0>>::Handle: Unpin, <C as Fork<T2>>::Future: Unpin, <C as Fork<T2>>::Target: Unpin, <C as Fork<T2>>::Finalize: Unpin, <C as Dispatch<T2>>::Handle: Unpin, <C as Fork<T1>>::Future: Unpin, <C as Fork<T1>>::Finalize: Unpin, <C as Fork<T1>>::Target: Unpin, <C as Dispatch<T1>>::Handle: Unpin, [src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>), (T0, T1, T2)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>), (T0, T1, T2)> as Future<C>>::Error) -> Tuple3UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>), (T0, T1, T2)> as Future<C>>::Error>>

`type Target = Tuple3Unravel<T0, T1, T2, C>`

`fn unravel(self) -> Self::Target`[src]

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle)> + Fork<T0> + Fork<T3> + Fork<T1> + Fork<T2> + Unpin> Unravel<C> for (T0, T1, T2, T3) where <C as Fork<T0>>::Future: Unpin, <C as Fork<T0>>::Target: Unpin, <C as Fork<T0>>::Finalize: Unpin, <C as Dispatch<T0>>::Handle: Unpin, <C as Fork<T3>>::Future: Unpin, <C as Fork<T3>>::Target: Unpin, <C as Fork<T3>>::Finalize: Unpin, <C as Dispatch<T3>>::Handle: Unpin, <C as Fork<T1>>::Future: Unpin, <C as Fork<T2>>::Future: Unpin, <C as Fork<T1>>::Finalize: Unpin, <C as Fork<T2>>::Finalize: Unpin, <C as Fork<T1>>::Target: Unpin, <C as Fork<T2>>::Target: Unpin, <C as Dispatch<T1>>::Handle: Unpin, <C as Dispatch<T2>>::Handle: Unpin, [src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>), (T0, T1, T2, T3)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>), (T0, T1, T2, T3)> as Future<C>>::Error) -> Tuple4UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>), (T0, T1, T2, T3)> as Future<C>>::Error>>

`type Target = Tuple4Unravel<T0, T1, T2, T3, C>`

`fn unravel(self) -> Self::Target`[src]

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle)> + Fork<T0> + Fork<T4> + Fork<T1> + Fork<T2> + Fork<T3> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4) where <C as Fork<T0>>::Future: Unpin, <C as Fork<T0>>::Target: Unpin, <C as Fork<T0>>::Finalize: Unpin, <C as Dispatch<T0>>::Handle: Unpin, <C as Fork<T4>>::Future: Unpin, <C as Fork<T4>>::Target: Unpin, <C as Fork<T4>>::Finalize: Unpin, <C as Dispatch<T4>>::Handle: Unpin, <C as Fork<T1>>::Future: Unpin, <C as Fork<T2>>::Future: Unpin, <C as Fork<T3>>::Future: Unpin, <C as Fork<T1>>::Finalize: Unpin, <C as Fork<T2>>::Finalize: Unpin, <C as Fork<T3>>::Finalize: Unpin, <C as Fork<T1>>::Target: Unpin, <C as Fork<T2>>::Target: Unpin, <C as Fork<T3>>::Target: Unpin, <C as Dispatch<T1>>::Handle: Unpin, <C as Dispatch<T2>>::Handle: Unpin, <C as Dispatch<T3>>::Handle: Unpin, [src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>), (T0, T1, T2, T3, T4)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>), (T0, T1, T2, T3, T4)> as Future<C>>::Error) -> Tuple5UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>), (T0, T1, T2, T3, T4)> as Future<C>>::Error>>

`type Target = Tuple5Unravel<T0, T1, T2, T3, T4, C>`

`fn unravel(self) -> Self::Target`[src]

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle)> + Fork<T0> + Fork<T5> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5) where <C as Fork<T0>>::Future: Unpin, <C as Fork<T0>>::Target: Unpin, <C as Fork<T0>>::Finalize: Unpin, <C as Dispatch<T0>>::Handle: Unpin, <C as Fork<T5>>::Future: Unpin, <C as Fork<T5>>::Target: Unpin, <C as Fork<T5>>::Finalize: Unpin, <C as Dispatch<T5>>::Handle: Unpin, <C as Fork<T1>>::Future: Unpin, <C as Fork<T2>>::Future: Unpin, <C as Fork<T3>>::Future: Unpin, <C as Fork<T4>>::Future: Unpin, <C as Fork<T1>>::Finalize: Unpin, <C as Fork<T2>>::Finalize: Unpin, <C as Fork<T3>>::Finalize: Unpin, <C as Fork<T4>>::Finalize: Unpin, <C as Fork<T1>>::Target: Unpin, <C as Fork<T2>>::Target: Unpin, <C as Fork<T3>>::Target: Unpin, <C as Fork<T4>>::Target: Unpin, <C as Dispatch<T1>>::Handle: Unpin, <C as Dispatch<T2>>::Handle: Unpin, <C as Dispatch<T3>>::Handle: Unpin, <C as Dispatch<T4>>::Handle: Unpin, [src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>), (T0, T1, T2, T3, T4, T5)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>), (T0, T1, T2, T3, T4, T5)> as Future<C>>::Error) -> Tuple6UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>), (T0, T1, T2, T3, T4, T5)> as Future<C>>::Error>>

`type Target = Tuple6Unravel<T0, T1, T2, T3, T4, T5, C>`

`fn unravel(self) -> Self::Target`[src]

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle)> + Fork<T0> + Fork<T6> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Fork<T5> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5, T6) where <C as Fork<T0>>::Future: Unpin, <C as Fork<T0>>::Target: Unpin, <C as Fork<T0>>::Finalize: Unpin, <C as Dispatch<T0>>::Handle: Unpin, <C as Fork<T6>>::Future: Unpin, <C as Fork<T6>>::Target: Unpin, <C as Fork<T6>>::Finalize: Unpin, <C as Dispatch<T6>>::Handle: Unpin, <C as Fork<T1>>::Future: Unpin, <C as Fork<T2>>::Future: Unpin, <C as Fork<T3>>::Future: Unpin, <C as Fork<T4>>::Future: Unpin, <C as Fork<T5>>::Future: Unpin, <C as Fork<T1>>::Finalize: Unpin, <C as Fork<T2>>::Finalize: Unpin, <C as Fork<T3>>::Finalize: Unpin, <C as Fork<T4>>::Finalize: Unpin, <C as Fork<T5>>::Finalize: Unpin, <C as Fork<T1>>::Target: Unpin, <C as Fork<T2>>::Target: Unpin, <C as Fork<T3>>::Target: Unpin, <C as Fork<T4>>::Target: Unpin, <C as Fork<T5>>::Target: Unpin, <C as Dispatch<T1>>::Handle: Unpin, <C as Dispatch<T2>>::Handle: Unpin, <C as Dispatch<T3>>::Handle: Unpin, <C as Dispatch<T4>>::Handle: Unpin, <C as Dispatch<T5>>::Handle: Unpin, [src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6)> as Future<C>>::Error) -> Tuple7UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <<C as Fork<T6>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5, T6)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6)> as Future<C>>::Error>>

`type Target = Tuple7Unravel<T0, T1, T2, T3, T4, T5, T6, C>`

`fn unravel(self) -> Self::Target`[src]

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, T7: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle)> + Fork<T0> + Fork<T7> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Fork<T5> + Fork<T6> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5, T6, T7) where <C as Fork<T0>>::Future: Unpin, <C as Fork<T0>>::Target: Unpin, <C as Fork<T0>>::Finalize: Unpin, <C as Dispatch<T0>>::Handle: Unpin, <C as Fork<T7>>::Future: Unpin, <C as Fork<T7>>::Target: Unpin, <C as Fork<T7>>::Finalize: Unpin, <C as Dispatch<T7>>::Handle: Unpin, <C as Fork<T1>>::Future: Unpin, <C as Fork<T2>>::Future: Unpin, <C as Fork<T3>>::Future: Unpin, <C as Fork<T4>>::Future: Unpin, <C as Fork<T5>>::Future: Unpin, <C as Fork<T6>>::Future: Unpin, <C as Fork<T1>>::Finalize: Unpin, <C as Fork<T2>>::Finalize: Unpin, <C as Fork<T3>>::Finalize: Unpin, <C as Fork<T4>>::Finalize: Unpin, <C as Fork<T5>>::Finalize: Unpin, <C as Fork<T6>>::Finalize: Unpin, <C as Fork<T1>>::Target: Unpin, <C as Fork<T2>>::Target: Unpin, <C as Fork<T3>>::Target: Unpin, <C as Fork<T4>>::Target: Unpin, <C as Fork<T5>>::Target: Unpin, <C as Fork<T6>>::Target: Unpin, <C as Dispatch<T1>>::Handle: Unpin, <C as Dispatch<T2>>::Handle: Unpin, <C as Dispatch<T3>>::Handle: Unpin, <C as Dispatch<T4>>::Handle: Unpin, <C as Dispatch<T5>>::Handle: Unpin, <C as Dispatch<T6>>::Handle: Unpin, [src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7)> as Future<C>>::Error) -> Tuple8UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <<C as Fork<T6>>::Future as Future<C>>::Error, <<C as Fork<T7>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5, T6, T7)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7)> as Future<C>>::Error>>

`type Target = Tuple8Unravel<T0, T1, T2, T3, T4, T5, T6, T7, C>`

`fn unravel(self) -> Self::Target`[src]

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, T7: Unpin, T8: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle)> + Fork<T0> + Fork<T8> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Fork<T5> + Fork<T6> + Fork<T7> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where <C as Fork<T0>>::Future: Unpin, <C as Fork<T0>>::Target: Unpin, <C as Fork<T0>>::Finalize: Unpin, <C as Dispatch<T0>>::Handle: Unpin, <C as Fork<T8>>::Future: Unpin, <C as Fork<T8>>::Target: Unpin, <C as Fork<T8>>::Finalize: Unpin, <C as Dispatch<T8>>::Handle: Unpin, <C as Fork<T1>>::Future: Unpin, <C as Fork<T2>>::Future: Unpin, <C as Fork<T3>>::Future: Unpin, <C as Fork<T4>>::Future: Unpin, <C as Fork<T5>>::Future: Unpin, <C as Fork<T6>>::Future: Unpin, <C as Fork<T7>>::Future: Unpin, <C as Fork<T1>>::Finalize: Unpin, <C as Fork<T2>>::Finalize: Unpin, <C as Fork<T3>>::Finalize: Unpin, <C as Fork<T4>>::Finalize: Unpin, <C as Fork<T5>>::Finalize: Unpin, <C as Fork<T6>>::Finalize: Unpin, <C as Fork<T7>>::Finalize: Unpin, <C as Fork<T1>>::Target: Unpin, <C as Fork<T2>>::Target: Unpin, <C as Fork<T3>>::Target: Unpin, <C as Fork<T4>>::Target: Unpin, <C as Fork<T5>>::Target: Unpin, <C as Fork<T6>>::Target: Unpin, <C as Fork<T7>>::Target: Unpin, <C as Dispatch<T1>>::Handle: Unpin, <C as Dispatch<T2>>::Handle: Unpin, <C as Dispatch<T3>>::Handle: Unpin, <C as Dispatch<T4>>::Handle: Unpin, <C as Dispatch<T5>>::Handle: Unpin, <C as Dispatch<T6>>::Handle: Unpin, <C as Dispatch<T7>>::Handle: Unpin, [src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8)> as Future<C>>::Error) -> Tuple9UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <<C as Fork<T6>>::Future as Future<C>>::Error, <<C as Fork<T7>>::Future as Future<C>>::Error, <<C as Fork<T8>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8)> as Future<C>>::Error>>

`type Target = Tuple9Unravel<T0, T1, T2, T3, T4, T5, T6, T7, T8, C>`

`fn unravel(self) -> Self::Target`[src]

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, T7: Unpin, T8: Unpin, T9: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle)> + Fork<T0> + Fork<T9> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Fork<T5> + Fork<T6> + Fork<T7> + Fork<T8> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where <C as Fork<T0>>::Future: Unpin, <C as Fork<T0>>::Target: Unpin, <C as Fork<T0>>::Finalize: Unpin, <C as Dispatch<T0>>::Handle: Unpin, <C as Fork<T9>>::Future: Unpin, <C as Fork<T9>>::Target: Unpin, <C as Fork<T9>>::Finalize: Unpin, <C as Dispatch<T9>>::Handle: Unpin, <C as Fork<T1>>::Future: Unpin, <C as Fork<T2>>::Future: Unpin, <C as Fork<T3>>::Future: Unpin, <C as Fork<T4>>::Future: Unpin, <C as Fork<T5>>::Future: Unpin, <C as Fork<T6>>::Future: Unpin, <C as Fork<T7>>::Future: Unpin, <C as Fork<T8>>::Future: Unpin, <C as Fork<T1>>::Finalize: Unpin, <C as Fork<T2>>::Finalize: Unpin, <C as Fork<T3>>::Finalize: Unpin, <C as Fork<T4>>::Finalize: Unpin, <C as Fork<T5>>::Finalize: Unpin, <C as Fork<T6>>::Finalize: Unpin, <C as Fork<T7>>::Finalize: Unpin, <C as Fork<T8>>::Finalize: Unpin, <C as Fork<T1>>::Target: Unpin, <C as Fork<T2>>::Target: Unpin, <C as Fork<T3>>::Target: Unpin, <C as Fork<T4>>::Target: Unpin, <C as Fork<T5>>::Target: Unpin, <C as Fork<T6>>::Target: Unpin, <C as Fork<T7>>::Target: Unpin, <C as Fork<T8>>::Target: Unpin, <C as Dispatch<T1>>::Handle: Unpin, <C as Dispatch<T2>>::Handle: Unpin, <C as Dispatch<T3>>::Handle: Unpin, <C as Dispatch<T4>>::Handle: Unpin, <C as Dispatch<T5>>::Handle: Unpin, <C as Dispatch<T6>>::Handle: Unpin, <C as Dispatch<T7>>::Handle: Unpin, <C as Dispatch<T8>>::Handle: Unpin, [src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> as Future<C>>::Error) -> Tuple10UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <<C as Fork<T6>>::Future as Future<C>>::Error, <<C as Fork<T7>>::Future as Future<C>>::Error, <<C as Fork<T8>>::Future as Future<C>>::Error, <<C as Fork<T9>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> as Future<C>>::Error>>

`type Target = Tuple10Unravel<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C>`

`fn unravel(self) -> Self::Target`[src]

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, T7: Unpin, T8: Unpin, T9: Unpin, T10: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle)> + Fork<T0> + Fork<T10> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Fork<T5> + Fork<T6> + Fork<T7> + Fork<T8> + Fork<T9> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where <C as Fork<T0>>::Future: Unpin, <C as Fork<T0>>::Target: Unpin, <C as Fork<T0>>::Finalize: Unpin, <C as Dispatch<T0>>::Handle: Unpin, <C as Fork<T10>>::Future: Unpin, <C as Fork<T10>>::Target: Unpin, <C as Fork<T10>>::Finalize: Unpin, <C as Dispatch<T10>>::Handle: Unpin, <C as Fork<T1>>::Future: Unpin, <C as Fork<T2>>::Future: Unpin, <C as Fork<T3>>::Future: Unpin, <C as Fork<T4>>::Future: Unpin, <C as Fork<T5>>::Future: Unpin, <C as Fork<T6>>::Future: Unpin, <C as Fork<T7>>::Future: Unpin, <C as Fork<T8>>::Future: Unpin, <C as Fork<T9>>::Future: Unpin, <C as Fork<T1>>::Finalize: Unpin, <C as Fork<T2>>::Finalize: Unpin, <C as Fork<T3>>::Finalize: Unpin, <C as Fork<T4>>::Finalize: Unpin, <C as Fork<T5>>::Finalize: Unpin, <C as Fork<T6>>::Finalize: Unpin, <C as Fork<T7>>::Finalize: Unpin, <C as Fork<T8>>::Finalize: Unpin, <C as Fork<T9>>::Finalize: Unpin, <C as Fork<T1>>::Target: Unpin, <C as Fork<T2>>::Target: Unpin, <C as Fork<T3>>::Target: Unpin, <C as Fork<T4>>::Target: Unpin, <C as Fork<T5>>::Target: Unpin, <C as Fork<T6>>::Target: Unpin, <C as Fork<T7>>::Target: Unpin, <C as Fork<T8>>::Target: Unpin, <C as Fork<T9>>::Target: Unpin, <C as Dispatch<T1>>::Handle: Unpin, <C as Dispatch<T2>>::Handle: Unpin, <C as Dispatch<T3>>::Handle: Unpin, <C as Dispatch<T4>>::Handle: Unpin, <C as Dispatch<T5>>::Handle: Unpin, <C as Dispatch<T6>>::Handle: Unpin, <C as Dispatch<T7>>::Handle: Unpin, <C as Dispatch<T8>>::Handle: Unpin, <C as Dispatch<T9>>::Handle: Unpin, [src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> as Future<C>>::Error) -> Tuple11UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <<C as Fork<T6>>::Future as Future<C>>::Error, <<C as Fork<T7>>::Future as Future<C>>::Error, <<C as Fork<T8>>::Future as Future<C>>::Error, <<C as Fork<T9>>::Future as Future<C>>::Error, <<C as Fork<T10>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> as Future<C>>::Error>>

`type Target = Tuple11Unravel<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, C>`

`fn unravel(self) -> Self::Target`[src]

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, T7: Unpin, T8: Unpin, T9: Unpin, T10: Unpin, T11: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle, <C as Dispatch<T11>>::Handle)> + Fork<T0> + Fork<T11> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Fork<T5> + Fork<T6> + Fork<T7> + Fork<T8> + Fork<T9> + Fork<T10> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where <C as Fork<T0>>::Future: Unpin, <C as Fork<T0>>::Target: Unpin, <C as Fork<T0>>::Finalize: Unpin, <C as Dispatch<T0>>::Handle: Unpin, <C as Fork<T11>>::Future: Unpin, <C as Fork<T11>>::Target: Unpin, <C as Fork<T11>>::Finalize: Unpin, <C as Dispatch<T11>>::Handle: Unpin, <C as Fork<T1>>::Future: Unpin, <C as Fork<T2>>::Future: Unpin, <C as Fork<T3>>::Future: Unpin, <C as Fork<T4>>::Future: Unpin, <C as Fork<T5>>::Future: Unpin, <C as Fork<T6>>::Future: Unpin, <C as Fork<T7>>::Future: Unpin, <C as Fork<T8>>::Future: Unpin, <C as Fork<T9>>::Future: Unpin, <C as Fork<T10>>::Future: Unpin, <C as Fork<T1>>::Finalize: Unpin, <C as Fork<T2>>::Finalize: Unpin, <C as Fork<T3>>::Finalize: Unpin, <C as Fork<T4>>::Finalize: Unpin, <C as Fork<T5>>::Finalize: Unpin, <C as Fork<T6>>::Finalize: Unpin, <C as Fork<T7>>::Finalize: Unpin, <C as Fork<T8>>::Finalize: Unpin, <C as Fork<T9>>::Finalize: Unpin, <C as Fork<T10>>::Finalize: Unpin, <C as Fork<T1>>::Target: Unpin, <C as Fork<T2>>::Target: Unpin, <C as Fork<T3>>::Target: Unpin, <C as Fork<T4>>::Target: Unpin, <C as Fork<T5>>::Target: Unpin, <C as Fork<T6>>::Target: Unpin, <C as Fork<T7>>::Target: Unpin, <C as Fork<T8>>::Target: Unpin, <C as Fork<T9>>::Target: Unpin, <C as Fork<T10>>::Target: Unpin, <C as Dispatch<T1>>::Handle: Unpin, <C as Dispatch<T2>>::Handle: Unpin, <C as Dispatch<T3>>::Handle: Unpin, <C as Dispatch<T4>>::Handle: Unpin, <C as Dispatch<T5>>::Handle: Unpin, <C as Dispatch<T6>>::Handle: Unpin, <C as Dispatch<T7>>::Handle: Unpin, <C as Dispatch<T8>>::Handle: Unpin, <C as Dispatch<T9>>::Handle: Unpin, <C as Dispatch<T10>>::Handle: Unpin, [src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> as Future<C>>::Error) -> Tuple12UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle, <C as Dispatch<T11>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <<C as Fork<T6>>::Future as Future<C>>::Error, <<C as Fork<T7>>::Future as Future<C>>::Error, <<C as Fork<T8>>::Future as Future<C>>::Error, <<C as Fork<T9>>::Future as Future<C>>::Error, <<C as Fork<T10>>::Future as Future<C>>::Error, <<C as Fork<T11>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> as Future<C>>::Error>>

`type Target = Tuple12Unravel<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, C>`

`fn unravel(self) -> Self::Target`[src]

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, T7: Unpin, T8: Unpin, T9: Unpin, T10: Unpin, T11: Unpin, T12: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle, <C as Dispatch<T11>>::Handle, <C as Dispatch<T12>>::Handle)> + Fork<T0> + Fork<T12> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Fork<T5> + Fork<T6> + Fork<T7> + Fork<T8> + Fork<T9> + Fork<T10> + Fork<T11> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where <C as Fork<T0>>::Future: Unpin, <C as Fork<T0>>::Target: Unpin, <C as Fork<T0>>::Finalize: Unpin, <C as Dispatch<T0>>::Handle: Unpin, <C as Fork<T12>>::Future: Unpin, <C as Fork<T12>>::Target: Unpin, <C as Fork<T12>>::Finalize: Unpin, <C as Dispatch<T12>>::Handle: Unpin, <C as Fork<T1>>::Future: Unpin, <C as Fork<T2>>::Future: Unpin, <C as Fork<T3>>::Future: Unpin, <C as Fork<T4>>::Future: Unpin, <C as Fork<T5>>::Future: Unpin, <C as Fork<T6>>::Future: Unpin, <C as Fork<T7>>::Future: Unpin, <C as Fork<T8>>::Future: Unpin, <C as Fork<T9>>::Future: Unpin, <C as Fork<T10>>::Future: Unpin, <C as Fork<T11>>::Future: Unpin, <C as Fork<T1>>::Finalize: Unpin, <C as Fork<T2>>::Finalize: Unpin, <C as Fork<T3>>::Finalize: Unpin, <C as Fork<T4>>::Finalize: Unpin, <C as Fork<T5>>::Finalize: Unpin, <C as Fork<T6>>::Finalize: Unpin, <C as Fork<T7>>::Finalize: Unpin, <C as Fork<T8>>::Finalize: Unpin, <C as Fork<T9>>::Finalize: Unpin, <C as Fork<T10>>::Finalize: Unpin, <C as Fork<T11>>::Finalize: Unpin, <C as Fork<T1>>::Target: Unpin, <C as Fork<T2>>::Target: Unpin, <C as Fork<T3>>::Target: Unpin, <C as Fork<T4>>::Target: Unpin, <C as Fork<T5>>::Target: Unpin, <C as Fork<T6>>::Target: Unpin, <C as Fork<T7>>::Target: Unpin, <C as Fork<T8>>::Target: Unpin, <C as Fork<T9>>::Target: Unpin, <C as Fork<T10>>::Target: Unpin, <C as Fork<T11>>::Target: Unpin, <C as Dispatch<T1>>::Handle: Unpin, <C as Dispatch<T2>>::Handle: Unpin, <C as Dispatch<T3>>::Handle: Unpin, <C as Dispatch<T4>>::Handle: Unpin, <C as Dispatch<T5>>::Handle: Unpin, <C as Dispatch<T6>>::Handle: Unpin, <C as Dispatch<T7>>::Handle: Unpin, <C as Dispatch<T8>>::Handle: Unpin, <C as Dispatch<T9>>::Handle: Unpin, <C as Dispatch<T10>>::Handle: Unpin, <C as Dispatch<T11>>::Handle: Unpin, [src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> as Future<C>>::Error) -> Tuple13UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle, <C as Dispatch<T11>>::Handle, <C as Dispatch<T12>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <<C as Fork<T6>>::Future as Future<C>>::Error, <<C as Fork<T7>>::Future as Future<C>>::Error, <<C as Fork<T8>>::Future as Future<C>>::Error, <<C as Fork<T9>>::Future as Future<C>>::Error, <<C as Fork<T10>>::Future as Future<C>>::Error, <<C as Fork<T11>>::Future as Future<C>>::Error, <<C as Fork<T12>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> as Future<C>>::Error>>

`type Target = Tuple13Unravel<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, C>`

`fn unravel(self) -> Self::Target`[src]

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, T7: Unpin, T8: Unpin, T9: Unpin, T10: Unpin, T11: Unpin, T12: Unpin, T13: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle, <C as Dispatch<T11>>::Handle, <C as Dispatch<T12>>::Handle, <C as Dispatch<T13>>::Handle)> + Fork<T0> + Fork<T13> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Fork<T5> + Fork<T6> + Fork<T7> + Fork<T8> + Fork<T9> + Fork<T10> + Fork<T11> + Fork<T12> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) where <C as Fork<T0>>::Future: Unpin, <C as Fork<T0>>::Target: Unpin, <C as Fork<T0>>::Finalize: Unpin, <C as Dispatch<T0>>::Handle: Unpin, <C as Fork<T13>>::Future: Unpin, <C as Fork<T13>>::Target: Unpin, <C as Fork<T13>>::Finalize: Unpin, <C as Dispatch<T13>>::Handle: Unpin, <C as Fork<T1>>::Future: Unpin, <C as Fork<T2>>::Future: Unpin, <C as Fork<T3>>::Future: Unpin, <C as Fork<T4>>::Future: Unpin, <C as Fork<T5>>::Future: Unpin, <C as Fork<T6>>::Future: Unpin, <C as Fork<T7>>::Future: Unpin, <C as Fork<T8>>::Future: Unpin, <C as Fork<T9>>::Future: Unpin, <C as Fork<T10>>::Future: Unpin, <C as Fork<T11>>::Future: Unpin, <C as Fork<T12>>::Future: Unpin, <C as Fork<T1>>::Finalize: Unpin, <C as Fork<T2>>::Finalize: Unpin, <C as Fork<T3>>::Finalize: Unpin, <C as Fork<T4>>::Finalize: Unpin, <C as Fork<T5>>::Finalize: Unpin, <C as Fork<T6>>::Finalize: Unpin, <C as Fork<T7>>::Finalize: Unpin, <C as Fork<T8>>::Finalize: Unpin, <C as Fork<T9>>::Finalize: Unpin, <C as Fork<T10>>::Finalize: Unpin, <C as Fork<T11>>::Finalize: Unpin, <C as Fork<T12>>::Finalize: Unpin, <C as Fork<T1>>::Target: Unpin, <C as Fork<T2>>::Target: Unpin, <C as Fork<T3>>::Target: Unpin, <C as Fork<T4>>::Target: Unpin, <C as Fork<T5>>::Target: Unpin, <C as Fork<T6>>::Target: Unpin, <C as Fork<T7>>::Target: Unpin, <C as Fork<T8>>::Target: Unpin, <C as Fork<T9>>::Target: Unpin, <C as Fork<T10>>::Target: Unpin, <C as Fork<T11>>::Target: Unpin, <C as Fork<T12>>::Target: Unpin, <C as Dispatch<T1>>::Handle: Unpin, <C as Dispatch<T2>>::Handle: Unpin, <C as Dispatch<T3>>::Handle: Unpin, <C as Dispatch<T4>>::Handle: Unpin, <C as Dispatch<T5>>::Handle: Unpin, <C as Dispatch<T6>>::Handle: Unpin, <C as Dispatch<T7>>::Handle: Unpin, <C as Dispatch<T8>>::Handle: Unpin, <C as Dispatch<T9>>::Handle: Unpin, <C as Dispatch<T10>>::Handle: Unpin, <C as Dispatch<T11>>::Handle: Unpin, <C as Dispatch<T12>>::Handle: Unpin, [src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>, Option<<C as Fork<T13>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>, Option<<C as Fork<T13>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> as Future<C>>::Error) -> Tuple14UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle, <C as Dispatch<T11>>::Handle, <C as Dispatch<T12>>::Handle, <C as Dispatch<T13>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <<C as Fork<T6>>::Future as Future<C>>::Error, <<C as Fork<T7>>::Future as Future<C>>::Error, <<C as Fork<T8>>::Future as Future<C>>::Error, <<C as Fork<T9>>::Future as Future<C>>::Error, <<C as Fork<T10>>::Future as Future<C>>::Error, <<C as Fork<T11>>::Future as Future<C>>::Error, <<C as Fork<T12>>::Future as Future<C>>::Error, <<C as Fork<T13>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>, Option<<C as Fork<T13>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> as Future<C>>::Error>>

`type Target = Tuple14Unravel<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, C>`

`fn unravel(self) -> Self::Target`[src]

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, T7: Unpin, T8: Unpin, T9: Unpin, T10: Unpin, T11: Unpin, T12: Unpin, T13: Unpin, T14: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle, <C as Dispatch<T11>>::Handle, <C as Dispatch<T12>>::Handle, <C as Dispatch<T13>>::Handle, <C as Dispatch<T14>>::Handle)> + Fork<T0> + Fork<T14> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Fork<T5> + Fork<T6> + Fork<T7> + Fork<T8> + Fork<T9> + Fork<T10> + Fork<T11> + Fork<T12> + Fork<T13> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) where <C as Fork<T0>>::Future: Unpin, <C as Fork<T0>>::Target: Unpin, <C as Fork<T0>>::Finalize: Unpin, <C as Dispatch<T0>>::Handle: Unpin, <C as Fork<T14>>::Future: Unpin, <C as Fork<T14>>::Target: Unpin, <C as Fork<T14>>::Finalize: Unpin, <C as Dispatch<T14>>::Handle: Unpin, <C as Fork<T1>>::Future: Unpin, <C as Fork<T2>>::Future: Unpin, <C as Fork<T3>>::Future: Unpin, <C as Fork<T4>>::Future: Unpin, <C as Fork<T5>>::Future: Unpin, <C as Fork<T6>>::Future: Unpin, <C as Fork<T7>>::Future: Unpin, <C as Fork<T8>>::Future: Unpin, <C as Fork<T9>>::Future: Unpin, <C as Fork<T10>>::Future: Unpin, <C as Fork<T11>>::Future: Unpin, <C as Fork<T12>>::Future: Unpin, <C as Fork<T13>>::Future: Unpin, <C as Fork<T1>>::Finalize: Unpin, <C as Fork<T2>>::Finalize: Unpin, <C as Fork<T3>>::Finalize: Unpin, <C as Fork<T4>>::Finalize: Unpin, <C as Fork<T5>>::Finalize: Unpin, <C as Fork<T6>>::Finalize: Unpin, <C as Fork<T7>>::Finalize: Unpin, <C as Fork<T8>>::Finalize: Unpin, <C as Fork<T9>>::Finalize: Unpin, <C as Fork<T10>>::Finalize: Unpin, <C as Fork<T11>>::Finalize: Unpin, <C as Fork<T12>>::Finalize: Unpin, <C as Fork<T13>>::Finalize: Unpin, <C as Fork<T1>>::Target: Unpin, <C as Fork<T2>>::Target: Unpin, <C as Fork<T3>>::Target: Unpin, <C as Fork<T4>>::Target: Unpin, <C as Fork<T5>>::Target: Unpin, <C as Fork<T6>>::Target: Unpin, <C as Fork<T7>>::Target: Unpin, <C as Fork<T8>>::Target: Unpin, <C as Fork<T9>>::Target: Unpin, <C as Fork<T10>>::Target: Unpin, <C as Fork<T11>>::Target: Unpin, <C as Fork<T12>>::Target: Unpin, <C as Fork<T13>>::Target: Unpin, <C as Dispatch<T1>>::Handle: Unpin, <C as Dispatch<T2>>::Handle: Unpin, <C as Dispatch<T3>>::Handle: Unpin, <C as Dispatch<T4>>::Handle: Unpin, <C as Dispatch<T5>>::Handle: Unpin, <C as Dispatch<T6>>::Handle: Unpin, <C as Dispatch<T7>>::Handle: Unpin, <C as Dispatch<T8>>::Handle: Unpin, <C as Dispatch<T9>>::Handle: Unpin, <C as Dispatch<T10>>::Handle: Unpin, <C as Dispatch<T11>>::Handle: Unpin, <C as Dispatch<T12>>::Handle: Unpin, <C as Dispatch<T13>>::Handle: Unpin, [src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>, Option<<C as Fork<T13>>::Finalize>, Option<<C as Fork<T14>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>, Option<<C as Fork<T13>>::Finalize>, Option<<C as Fork<T14>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> as Future<C>>::Error) -> Tuple15UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle, <C as Dispatch<T11>>::Handle, <C as Dispatch<T12>>::Handle, <C as Dispatch<T13>>::Handle, <C as Dispatch<T14>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <<C as Fork<T6>>::Future as Future<C>>::Error, <<C as Fork<T7>>::Future as Future<C>>::Error, <<C as Fork<T8>>::Future as Future<C>>::Error, <<C as Fork<T9>>::Future as Future<C>>::Error, <<C as Fork<T10>>::Future as Future<C>>::Error, <<C as Fork<T11>>::Future as Future<C>>::Error, <<C as Fork<T12>>::Future as Future<C>>::Error, <<C as Fork<T13>>::Future as Future<C>>::Error, <<C as Fork<T14>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>, Option<<C as Fork<T13>>::Finalize>, Option<<C as Fork<T14>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> as Future<C>>::Error>>

`type Target = Tuple15Unravel<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, C>`

`fn unravel(self) -> Self::Target`[src]

impl<T0: Unpin, T1: Unpin, T2: Unpin, T3: Unpin, T4: Unpin, T5: Unpin, T6: Unpin, T7: Unpin, T8: Unpin, T9: Unpin, T10: Unpin, T11: Unpin, T12: Unpin, T13: Unpin, T14: Unpin, T15: Unpin, C: ?Sized + Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle, <C as Dispatch<T11>>::Handle, <C as Dispatch<T12>>::Handle, <C as Dispatch<T13>>::Handle, <C as Dispatch<T14>>::Handle, <C as Dispatch<T15>>::Handle)> + Fork<T0> + Fork<T15> + Fork<T1> + Fork<T2> + Fork<T3> + Fork<T4> + Fork<T5> + Fork<T6> + Fork<T7> + Fork<T8> + Fork<T9> + Fork<T10> + Fork<T11> + Fork<T12> + Fork<T13> + Fork<T14> + Unpin> Unravel<C> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) where <C as Fork<T0>>::Future: Unpin, <C as Fork<T0>>::Target: Unpin, <C as Fork<T0>>::Finalize: Unpin, <C as Dispatch<T0>>::Handle: Unpin, <C as Fork<T15>>::Future: Unpin, <C as Fork<T15>>::Target: Unpin, <C as Fork<T15>>::Finalize: Unpin, <C as Dispatch<T15>>::Handle: Unpin, <C as Fork<T1>>::Future: Unpin, <C as Fork<T2>>::Future: Unpin, <C as Fork<T3>>::Future: Unpin, <C as Fork<T4>>::Future: Unpin, <C as Fork<T5>>::Future: Unpin, <C as Fork<T6>>::Future: Unpin, <C as Fork<T7>>::Future: Unpin, <C as Fork<T8>>::Future: Unpin, <C as Fork<T9>>::Future: Unpin, <C as Fork<T10>>::Future: Unpin, <C as Fork<T11>>::Future: Unpin, <C as Fork<T12>>::Future: Unpin, <C as Fork<T13>>::Future: Unpin, <C as Fork<T14>>::Future: Unpin, <C as Fork<T1>>::Finalize: Unpin, <C as Fork<T2>>::Finalize: Unpin, <C as Fork<T3>>::Finalize: Unpin, <C as Fork<T4>>::Finalize: Unpin, <C as Fork<T5>>::Finalize: Unpin, <C as Fork<T6>>::Finalize: Unpin, <C as Fork<T7>>::Finalize: Unpin, <C as Fork<T8>>::Finalize: Unpin, <C as Fork<T9>>::Finalize: Unpin, <C as Fork<T10>>::Finalize: Unpin, <C as Fork<T11>>::Finalize: Unpin, <C as Fork<T12>>::Finalize: Unpin, <C as Fork<T13>>::Finalize: Unpin, <C as Fork<T14>>::Finalize: Unpin, <C as Fork<T1>>::Target: Unpin, <C as Fork<T2>>::Target: Unpin, <C as Fork<T3>>::Target: Unpin, <C as Fork<T4>>::Target: Unpin, <C as Fork<T5>>::Target: Unpin, <C as Fork<T6>>::Target: Unpin, <C as Fork<T7>>::Target: Unpin, <C as Fork<T8>>::Target: Unpin, <C as Fork<T9>>::Target: Unpin, <C as Fork<T10>>::Target: Unpin, <C as Fork<T11>>::Target: Unpin, <C as Fork<T12>>::Target: Unpin, <C as Fork<T13>>::Target: Unpin, <C as Fork<T14>>::Target: Unpin, <C as Dispatch<T1>>::Handle: Unpin, <C as Dispatch<T2>>::Handle: Unpin, <C as Dispatch<T3>>::Handle: Unpin, <C as Dispatch<T4>>::Handle: Unpin, <C as Dispatch<T5>>::Handle: Unpin, <C as Dispatch<T6>>::Handle: Unpin, <C as Dispatch<T7>>::Handle: Unpin, <C as Dispatch<T8>>::Handle: Unpin, <C as Dispatch<T9>>::Handle: Unpin, <C as Dispatch<T10>>::Handle: Unpin, <C as Dispatch<T11>>::Handle: Unpin, <C as Dispatch<T12>>::Handle: Unpin, <C as Dispatch<T13>>::Handle: Unpin, <C as Dispatch<T14>>::Handle: Unpin, [src]

type Finalize = MapErr<TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>, Option<<C as Fork<T13>>::Finalize>, Option<<C as Fork<T14>>::Finalize>, Option<<C as Fork<T15>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>, fn(_: <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>, Option<<C as Fork<T13>>::Finalize>, Option<<C as Fork<T14>>::Finalize>, Option<<C as Fork<T15>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> as Future<C>>::Error) -> Tuple16UnravelError<<C as Write<(<C as Dispatch<T0>>::Handle, <C as Dispatch<T1>>::Handle, <C as Dispatch<T2>>::Handle, <C as Dispatch<T3>>::Handle, <C as Dispatch<T4>>::Handle, <C as Dispatch<T5>>::Handle, <C as Dispatch<T6>>::Handle, <C as Dispatch<T7>>::Handle, <C as Dispatch<T8>>::Handle, <C as Dispatch<T9>>::Handle, <C as Dispatch<T10>>::Handle, <C as Dispatch<T11>>::Handle, <C as Dispatch<T12>>::Handle, <C as Dispatch<T13>>::Handle, <C as Dispatch<T14>>::Handle, <C as Dispatch<T15>>::Handle)>>::Error, <<C as Fork<T0>>::Future as Future<C>>::Error, <<C as Fork<T1>>::Future as Future<C>>::Error, <<C as Fork<T2>>::Future as Future<C>>::Error, <<C as Fork<T3>>::Future as Future<C>>::Error, <<C as Fork<T4>>::Future as Future<C>>::Error, <<C as Fork<T5>>::Future as Future<C>>::Error, <<C as Fork<T6>>::Future as Future<C>>::Error, <<C as Fork<T7>>::Future as Future<C>>::Error, <<C as Fork<T8>>::Future as Future<C>>::Error, <<C as Fork<T9>>::Future as Future<C>>::Error, <<C as Fork<T10>>::Future as Future<C>>::Error, <<C as Fork<T11>>::Future as Future<C>>::Error, <<C as Fork<T12>>::Future as Future<C>>::Error, <<C as Fork<T13>>::Future as Future<C>>::Error, <<C as Fork<T14>>::Future as Future<C>>::Error, <<C as Fork<T15>>::Future as Future<C>>::Error, <Finalize<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> as Future<C>>::Error, <TupleFinalizeInner<(Option<<C as Fork<T0>>::Finalize>, Option<<C as Fork<T1>>::Finalize>, Option<<C as Fork<T2>>::Finalize>, Option<<C as Fork<T3>>::Finalize>, Option<<C as Fork<T4>>::Finalize>, Option<<C as Fork<T5>>::Finalize>, Option<<C as Fork<T6>>::Finalize>, Option<<C as Fork<T7>>::Finalize>, Option<<C as Fork<T8>>::Finalize>, Option<<C as Fork<T9>>::Finalize>, Option<<C as Fork<T10>>::Finalize>, Option<<C as Fork<T11>>::Finalize>, Option<<C as Fork<T12>>::Finalize>, Option<<C as Fork<T13>>::Finalize>, Option<<C as Fork<T14>>::Finalize>, Option<<C as Fork<T15>>::Finalize>), (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> as Future<C>>::Error>>

`type Target = Tuple16Unravel<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Write<<C as Dispatch<([String; 2], Vec<[String; 2]>)>>::Handle> + Fork<([String; 2], Vec<[String; 2]>)> + Unpin> Unravel<C> for Box<dyn Error> where C::Future: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin,` [src]

`type Finalize = <FlatUnravel<([String; 2], Vec<[String; 2]>), C> as Future<C>>::Ok`

`type Target = FlatUnravel<([String; 2], Vec<[String; 2]>), C>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Write<<C as Dispatch<([String; 2], Vec<[String; 2]>)>>::Handle> + Fork<([String; 2], Vec<[String; 2]>)> + Unpin> Unravel<C> for Box<dyn Error + Sync> where C::Future: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin,` [src]

`type Finalize = <FlatUnravel<([String; 2], Vec<[String; 2]>), C> as Future<C>>::Ok`

`type Target = FlatUnravel<([String; 2], Vec<[String; 2]>), C>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Write<<C as Dispatch<([String; 2], Vec<[String; 2]>)>>::Handle> + Fork<([String; 2], Vec<[String; 2]>)> + Unpin> Unravel<C> for Box<dyn Error + Send> where C::Future: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin,` [src]

`type Finalize = <FlatUnravel<([String; 2], Vec<[String; 2]>), C> as Future<C>>::Ok`

`type Target = FlatUnravel<([String; 2], Vec<[String; 2]>), C>`

`fn unravel(self) -> Self::Target`[src]

`impl<C: ?Sized + Write<<C as Dispatch<([String; 2], Vec<[String; 2]>)>>::Handle> + Fork<([String; 2], Vec<[String; 2]>)> + Unpin> Unravel<C> for Box<dyn Error + Sync + Send> where C::Future: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin,` [src]

`type Finalize = <FlatUnravel<([String; 2], Vec<[String; 2]>), C> as Future<C>>::Ok`

`type Target = FlatUnravel<([String; 2], Vec<[String; 2]>), C>`

`fn unravel(self) -> Self::Target`[src]

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce() -> U + 'a> where RefContextTarget<C>: Notify<()> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<()>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<()>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (), U, Box<dyn FnOnce() -> U + 'a>, fn(_: Box<dyn FnOnce() -> U + 'a>, _: ()) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<()>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0) -> U + 'a> where RefContextTarget<C>: Notify<(T0,)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0,)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0,), U, Box<dyn FnOnce(T0) -> U + 'a>, fn(_: Box<dyn FnOnce(T0) -> U + 'a>, _: (T0,)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1) -> U + 'a> where RefContextTarget<C>: Notify<(T0, T1)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1), U, Box<dyn FnOnce(T0, T1) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1) -> U + 'a>, _: (T0, T1)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2) -> U + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2), U, Box<dyn FnOnce(T0, T1, T2) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2) -> U + 'a>, _: (T0, T1, T2)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3) -> U + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3), U, Box<dyn FnOnce(T0, T1, T2, T3) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3) -> U + 'a>, _: (T0, T1, T2, T3)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4), U, Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + 'a>, _: (T0, T1, T2, T3, T4)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce() -> U + Sync + 'a> where RefContextTarget<C>: Notify<()> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<()>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<()>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (), U, Box<dyn FnOnce() -> U + Sync + 'a>, fn(_: Box<dyn FnOnce() -> U + Sync + 'a>, _: ()) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<()>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0) -> U + Sync + 'a> where RefContextTarget<C>: Notify<(T0,)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0,)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0,), U, Box<dyn FnOnce(T0) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0) -> U + Sync + 'a>, _: (T0,)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1) -> U + Sync + 'a> where RefContextTarget<C>: Notify<(T0, T1)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1), U, Box<dyn FnOnce(T0, T1) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1) -> U + Sync + 'a>, _: (T0, T1)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2) -> U + Sync + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2), U, Box<dyn FnOnce(T0, T1, T2) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2) -> U + Sync + 'a>, _: (T0, T1, T2)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3) -> U + Sync + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3), U, Box<dyn FnOnce(T0, T1, T2, T3) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3) -> U + Sync + 'a>, _: (T0, T1, T2, T3)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + Sync + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4), U, Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + Sync + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + Sync + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Sync + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Sync + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Sync + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Sync + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Sync + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Sync + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Sync + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Sync + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Sync + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Sync + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Sync + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce() -> U + Send + 'a> where RefContextTarget<C>: Notify<()> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<()>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<()>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (), U, Box<dyn FnOnce() -> U + Send + 'a>, fn(_: Box<dyn FnOnce() -> U + Send + 'a>, _: ()) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<()>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0) -> U + Send + 'a> where RefContextTarget<C>: Notify<(T0,)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0,)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0,), U, Box<dyn FnOnce(T0) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0) -> U + Send + 'a>, _: (T0,)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1) -> U + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1), U, Box<dyn FnOnce(T0, T1) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1) -> U + Send + 'a>, _: (T0, T1)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2) -> U + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2), U, Box<dyn FnOnce(T0, T1, T2) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2) -> U + Send + 'a>, _: (T0, T1, T2)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3) -> U + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3), U, Box<dyn FnOnce(T0, T1, T2, T3) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3) -> U + Send + 'a>, _: (T0, T1, T2, T3)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4), U, Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce() -> U + Sync + Send + 'a> where RefContextTarget<C>: Notify<()> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<()>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<()>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (), U, Box<dyn FnOnce() -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce() -> U + Sync + Send + 'a>, _: ()) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<()>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0) -> U + Sync + Send + 'a> where RefContextTarget<C>: Notify<(T0,)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0,)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0,), U, Box<dyn FnOnce(T0) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0) -> U + Sync + Send + 'a>, _: (T0,)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1) -> U + Sync + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1), U, Box<dyn FnOnce(T0, T1) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1) -> U + Sync + Send + 'a>, _: (T0, T1)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2) -> U + Sync + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2), U, Box<dyn FnOnce(T0, T1, T2) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2) -> U + Sync + Send + 'a>, _: (T0, T1, T2)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3) -> U + Sync + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3), U, Box<dyn FnOnce(T0, T1, T2, T3) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + Sync + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4), U, Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + Sync + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + Sync + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Sync + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Sync + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Sync + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Sync + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Sync + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Sync + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Sync + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Sync + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Sync + Send + 'a> where RefContextTarget<C>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork + Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<C> as Dispatch>::Handle>, U: Unpin, <RefContextTarget<C> as Fork>::Target: Unpin, <RefContextTarget<C> as Fork>::Future: Unpin, <RefContextTarget<C> as Fork>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin, <RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, [src]

`type Finalize = ErasedFnOnceUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Sync + Send + 'a>, fn(_: Box<dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Sync + Send + 'a>, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Option<Self>, fn(_: Option<Self>, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnOnceUnravelError<<RefContextTarget<C> as Read<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<<RefContextTarget<C> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch>::Handle>>::Error, <<RefContextTarget<C> as Fork>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut() -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<()> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (), U, Self, fn(_: &mut Self, _: ()) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0,)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0,), U, Self, fn(_: &mut Self, _: (T0,)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1), U, Self, fn(_: &mut Self, _: (T0, T1)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2), U, Self, fn(_: &mut Self, _: (T0, T1, T2)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn() -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<()> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (), U, Self, fn(_: &mut Self, _: ()) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0,)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0,), U, Self, fn(_: &mut Self, _: (T0,)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1), U, Self, fn(_: &mut Self, _: (T0, T1)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2), U, Self, fn(_: &mut Self, _: (T0, T1, T2)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut() -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<()> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (), U, Self, fn(_: &mut Self, _: ()) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0,)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0,), U, Self, fn(_: &mut Self, _: (T0,)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1), U, Self, fn(_: &mut Self, _: (T0, T1)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2), U, Self, fn(_: &mut Self, _: (T0, T1, T2)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn() -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<()> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (), U, Self, fn(_: &mut Self, _: ()) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0,)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0,), U, Self, fn(_: &mut Self, _: (T0,)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1), U, Self, fn(_: &mut Self, _: (T0, T1)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2), U, Self, fn(_: &mut Self, _: (T0, T1, T2)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Sync + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut() -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<()> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (), U, Self, fn(_: &mut Self, _: ()) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0,)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0,), U, Self, fn(_: &mut Self, _: (T0,)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1), U, Self, fn(_: &mut Self, _: (T0, T1)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2), U, Self, fn(_: &mut Self, _: (T0, T1, T2)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn() -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<()> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (), U, Self, fn(_: &mut Self, _: ()) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0,)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0,), U, Self, fn(_: &mut Self, _: (T0,)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1), U, Self, fn(_: &mut Self, _: (T0, T1)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2), U, Self, fn(_: &mut Self, _: (T0, T1, T2)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut() -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<()> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (), U, Self, fn(_: &mut Self, _: ()) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0,)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0,), U, Self, fn(_: &mut Self, _: (T0,)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1), U, Self, fn(_: &mut Self, _: (T0, T1)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2), U, Self, fn(_: &mut Self, _: (T0, T1, T2)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn() -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<()> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (), U, Self, fn(_: &mut Self, _: ()) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<()>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0,)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0,), U, Self, fn(_: &mut Self, _: (T0,)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0,)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1), U, Self, fn(_: &mut Self, _: (T0, T1)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2), U, Self, fn(_: &mut Self, _: (T0, T1, T2)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T0: 'a, T1: 'a, T2: 'a, T3: 'a, T4: 'a, T5: 'a, T6: 'a, T7: 'a, T8: 'a, T9: 'a, T10: 'a, T11: 'a, T12: 'a, T13: 'a, T14: 'a, T15: 'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext> Unravel<C> for Box<dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> U + Sync + Send + 'a> where RefContextTarget<C>: ReferenceContext + Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>, RefContextTarget<RefContextTarget<C>>: Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> + Fork + Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle> + Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>, RefContextTarget<RefContextTarget<C>>: Unpin, <RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future: Unpin, <RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Target: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Finalize: Unpin, <RefContextTarget<RefContextTarget<C>> as Fork>::Future: Unpin, C::ForkOutput: Unpin, C: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as ReferenceContext>::JoinOutput: Unpin, [src]

`type Finalize = ErasedFnUnravel<C, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, Self, fn(_: &mut Self, _: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> U>`

type Target = MapErr<ForkContextRef<C, Self::Finalize, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> Self::Finalize>, fn(_: ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>) -> FnUnravelError<<RefContextTarget<RefContextTarget<C>> as Read<<RefContextTarget<RefContextTarget<C>> as Dispatch<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Unwrap as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Join<<RefContextTarget<RefContextTarget<C>> as Notify<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>>::Notification>>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, ForkContextRefError<<<C as ReferenceContext>::ForkOutput as Future<C>>::Error, <C as Write<<C as Contextualize>::Handle>>::Error>, <RefContextTarget<RefContextTarget<C>> as Write<<RefContextTarget<RefContextTarget<C>> as Dispatch>::Handle>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Future as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Target as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <<RefContextTarget<RefContextTarget<C>> as Fork>::Finalize as Future<RefContextTarget<RefContextTarget<C>>>>::Error, <RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Contextualize>::Handle>>>::Error, <<RefContextTarget<C> as ReferenceContext>::JoinOutput as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Pin<Box<dyn Future<Output = T> + 'a>> where RefContextTarget<C>: Write<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, T>>>::Handle> + Notify<T>, T: Unpin, C::ForkOutput: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Finalize: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Future: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Target: Unpin, T: Unpin, <RefContextTarget<C> as Notify<T>>::Wrap: Unpin, [src]

`type Finalize = ErasedFutureUnravel<Self, C>`

type Target = MapErr<Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>>, fn(_: <Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>> as Future<C>>::Error) -> FutureUnravelError<<Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>> as Future<C>>::Error, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<Self::Output>>::Wrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Pin<Box<dyn Future<Output = T> + Sync + 'a>> where RefContextTarget<C>: Write<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, T>>>::Handle> + Notify<T>, T: Unpin, C::ForkOutput: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Finalize: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Future: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Target: Unpin, T: Unpin, <RefContextTarget<C> as Notify<T>>::Wrap: Unpin, [src]

`type Finalize = ErasedFutureUnravel<Self, C>`

type Target = MapErr<Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>>, fn(_: <Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>> as Future<C>>::Error) -> FutureUnravelError<<Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>> as Future<C>>::Error, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<Self::Output>>::Wrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Pin<Box<dyn Future<Output = T> + Send + 'a>> where RefContextTarget<C>: Write<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, T>>>::Handle> + Notify<T>, T: Unpin, C::ForkOutput: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Finalize: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Future: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Target: Unpin, T: Unpin, <RefContextTarget<C> as Notify<T>>::Wrap: Unpin, [src]

`type Finalize = ErasedFutureUnravel<Self, C>`

type Target = MapErr<Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>>, fn(_: <Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>> as Future<C>>::Error) -> FutureUnravelError<<Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>> as Future<C>>::Error, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<Self::Output>>::Wrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, T, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Pin<Box<dyn Future<Output = T> + Sync + Send + 'a>> where RefContextTarget<C>: Write<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, T>>>::Handle> + Notify<T>, T: Unpin, C::ForkOutput: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Finalize: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Future: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, T>>>::Target: Unpin, T: Unpin, <RefContextTarget<C> as Notify<T>>::Wrap: Unpin, [src]

`type Finalize = ErasedFutureUnravel<Self, C>`

type Target = MapErr<Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>>, fn(_: <Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>> as Future<C>>::Error) -> FutureUnravelError<<Fcr<C, ErasedFutureUnravel<Self, C>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedFutureUnravel<Self, C>> as Future<C>>::Error, <RefContextTarget<C> as Write<<RefContextTarget<C> as Dispatch<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Handle>>::Error, <<RefContextTarget<C> as Notify<Self::Output>>::Wrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<<RefContextTarget<C> as Notify<Self::Output>>::Notification>>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Pin<Box<dyn Stream<Item = U> + 'a>> where RefContextTarget<C>: Notify<()> + Notify + Read<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, ()>>>::Handle>> + Write<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, U>>>::Handle>>, U: Unpin, C: Unpin, C::ForkOutput: Unpin, <RefContextTarget<C> as Notify>::Wrap: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Target: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Future: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<()>>::Unwrap: Unpin, <RefContextTarget<C> as Join<Notification<RefContextTarget<C>, ()>>>::Future: Unpin, [src]

`type Finalize = ErasedStreamUnravel<C, Self>`

type Target = MapErr<Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>>, fn(_: <Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>> as Future<C>>::Error) -> StreamUnravelError<<RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, ()>>>::Handle>>>::Error, <<RefContextTarget<C> as Notify<()>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<Notification<RefContextTarget<C>, ()>>>::Future as Future<RefContextTarget<C>>>::Error, <Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>> as Future<C>>::Error, <RefContextTarget<C> as Write<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, Self::Item>>>::Handle>>>::Error, <<RefContextTarget<C> as Notify<Self::Item>>::Wrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Pin<Box<dyn Stream<Item = U> + Sync + 'a>> where RefContextTarget<C>: Notify<()> + Notify + Read<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, ()>>>::Handle>> + Write<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, U>>>::Handle>>, U: Unpin, C: Unpin, C::ForkOutput: Unpin, <RefContextTarget<C> as Notify>::Wrap: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Target: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Future: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<()>>::Unwrap: Unpin, <RefContextTarget<C> as Join<Notification<RefContextTarget<C>, ()>>>::Future: Unpin, [src]

`type Finalize = ErasedStreamUnravel<C, Self>`

type Target = MapErr<Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>>, fn(_: <Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>> as Future<C>>::Error) -> StreamUnravelError<<RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, ()>>>::Handle>>>::Error, <<RefContextTarget<C> as Notify<()>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<Notification<RefContextTarget<C>, ()>>>::Future as Future<RefContextTarget<C>>>::Error, <Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>> as Future<C>>::Error, <RefContextTarget<C> as Write<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, Self::Item>>>::Handle>>>::Error, <<RefContextTarget<C> as Notify<Self::Item>>::Wrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Pin<Box<dyn Stream<Item = U> + Send + 'a>> where RefContextTarget<C>: Notify<()> + Notify + Read<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, ()>>>::Handle>> + Write<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, U>>>::Handle>>, U: Unpin, C: Unpin, C::ForkOutput: Unpin, <RefContextTarget<C> as Notify>::Wrap: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Target: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Future: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<()>>::Unwrap: Unpin, <RefContextTarget<C> as Join<Notification<RefContextTarget<C>, ()>>>::Future: Unpin, [src]

`type Finalize = ErasedStreamUnravel<C, Self>`

type Target = MapErr<Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>>, fn(_: <Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>> as Future<C>>::Error) -> StreamUnravelError<<RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, ()>>>::Handle>>>::Error, <<RefContextTarget<C> as Notify<()>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<Notification<RefContextTarget<C>, ()>>>::Future as Future<RefContextTarget<C>>>::Error, <Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>> as Future<C>>::Error, <RefContextTarget<C> as Write<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, Self::Item>>>::Handle>>>::Error, <<RefContextTarget<C> as Notify<Self::Item>>::Wrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

impl<'a, U: 'a, C: ?Sized + Write<<C as Contextualize>::Handle> + ReferenceContext + Unpin> Unravel<C> for Pin<Box<dyn Stream<Item = U> + Sync + Send + 'a>> where RefContextTarget<C>: Notify<()> + Notify + Read<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, ()>>>::Handle>> + Write<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, U>>>::Handle>>, U: Unpin, C: Unpin, C::ForkOutput: Unpin, <RefContextTarget<C> as Notify>::Wrap: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Target: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Future: Unpin, <RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, U>>>::Finalize: Unpin, RefContextTarget<C>: Unpin, <RefContextTarget<C> as Notify<()>>::Unwrap: Unpin, <RefContextTarget<C> as Join<Notification<RefContextTarget<C>, ()>>>::Future: Unpin, [src]

`type Finalize = ErasedStreamUnravel<C, Self>`

type Target = MapErr<Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>>, fn(_: <Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>> as Future<C>>::Error) -> StreamUnravelError<<RefContextTarget<C> as Read<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, ()>>>::Handle>>>::Error, <<RefContextTarget<C> as Notify<()>>::Unwrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Join<Notification<RefContextTarget<C>, ()>>>::Future as Future<RefContextTarget<C>>>::Error, <Fcr<C, ErasedStreamUnravel<C, Self>, Self, fn(_: Self, _: <C as ReferenceContext>::Context) -> ErasedStreamUnravel<C, Self>> as Future<C>>::Error, <RefContextTarget<C> as Write<Option<<RefContextTarget<C> as Dispatch<Notification<RefContextTarget<C>, Self::Item>>>::Handle>>>::Error, <<RefContextTarget<C> as Notify<Self::Item>>::Wrap as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Future as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Target as Future<RefContextTarget<C>>>::Error, <<RefContextTarget<C> as Fork<Notification<RefContextTarget<C>, Self::Item>>>::Finalize as Future<RefContextTarget<C>>>::Error>>

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<Vec<<C as Dispatch<T>>::Handle>> + Fork<T> + Unpin> Unravel<C> for Vec<T> where T: Unpin, C::Handle: Unpin, C::Future: Unpin, C::Finalize: Unpin, C::Target: Unpin,` [src]

`type Finalize = MapErr<VecFinalize<C, T>, fn(_: <VecFinalize<C, T> as Future<C>>::Error) -> VecUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = VecUnravel<Rev<IntoIter<T>>, C>`

`fn unravel(self) -> Self::Target`[src]

Loading content...

Implementors

`impl<C: ?Sized> Unravel<C> for ProtocolError where Box<dyn Error + Send>: Unravel<C>,` [src]

`type Finalize = <Box<dyn Error + Send> as Unravel<C>>::Finalize`

`type Target = <Box<dyn Error + Send> as Unravel<C>>::Target`

`fn unravel(self) -> Self::Target`[src]

Loading content...

[−][src]Trait protocol::Unravel

Associated Types

type Finalize: Future<C, Ok = (), Error = <Self::Target as Future<C>>::Error>

type Target: Future<C, Ok = Self::Finalize>

Required methods

fn unravel(self) -> Self::Target

Implementations on Foreign Types

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 2]> + Fork<T> + Unpin> Unravel<C> for [T; 2] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin, [src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 2]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0002Unravel<T, C>

fn unravel(self) -> Self::Target[src]

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 3]> + Fork<T> + Unpin> Unravel<C> for [T; 3] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin, [src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 3]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0003Unravel<T, C>

fn unravel(self) -> Self::Target[src]

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 4]> + Fork<T> + Unpin> Unravel<C> for [T; 4] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin, [src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 4]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0004Unravel<T, C>

fn unravel(self) -> Self::Target[src]

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 5]> + Fork<T> + Unpin> Unravel<C> for [T; 5] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin, [src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 5]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0005Unravel<T, C>

fn unravel(self) -> Self::Target[src]

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 6]> + Fork<T> + Unpin> Unravel<C> for [T; 6] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin, [src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 6]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0006Unravel<T, C>

fn unravel(self) -> Self::Target[src]

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 7]> + Fork<T> + Unpin> Unravel<C> for [T; 7] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin, [src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 7]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0007Unravel<T, C>

fn unravel(self) -> Self::Target[src]

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 8]> + Fork<T> + Unpin> Unravel<C> for [T; 8] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin, [src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 8]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0008Unravel<T, C>

fn unravel(self) -> Self::Target[src]

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 9]> + Fork<T> + Unpin> Unravel<C> for [T; 9] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin, [src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 9]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0009Unravel<T, C>

fn unravel(self) -> Self::Target[src]

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 10]> + Fork<T> + Unpin> Unravel<C> for [T; 10] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin, [src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 10]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0010Unravel<T, C>

fn unravel(self) -> Self::Target[src]

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 11]> + Fork<T> + Unpin> Unravel<C> for [T; 11] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin, [src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 11]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0011Unravel<T, C>

fn unravel(self) -> Self::Target[src]

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 12]> + Fork<T> + Unpin> Unravel<C> for [T; 12] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin, [src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 12]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0012Unravel<T, C>

fn unravel(self) -> Self::Target[src]

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 13]> + Fork<T> + Unpin> Unravel<C> for [T; 13] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin, [src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 13]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0013Unravel<T, C>

fn unravel(self) -> Self::Target[src]

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 14]> + Fork<T> + Unpin> Unravel<C> for [T; 14] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin, [src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 14]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0014Unravel<T, C>

fn unravel(self) -> Self::Target[src]

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 15]> + Fork<T> + Unpin> Unravel<C> for [T; 15] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin, [src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 15]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0015Unravel<T, C>

fn unravel(self) -> Self::Target[src]

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 16]> + Fork<T> + Unpin> Unravel<C> for [T; 16] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin, [src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 16]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0016Unravel<T, C>

fn unravel(self) -> Self::Target[src]

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 17]> + Fork<T> + Unpin> Unravel<C> for [T; 17] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin, [src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 17]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0017Unravel<T, C>

fn unravel(self) -> Self::Target[src]

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 18]> + Fork<T> + Unpin> Unravel<C> for [T; 18] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin, [src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 18]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0018Unravel<T, C>

fn unravel(self) -> Self::Target[src]

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 19]> + Fork<T> + Unpin> Unravel<C> for [T; 19] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin, [src]

type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 19]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>

type Target = Array0019Unravel<T, C>

fn unravel(self) -> Self::Target[src]

impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 20]> + Fork<T> + Unpin> Unravel<C> for [T; 20] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin, [src]

`type Finalize: Future<C, Ok = (), Error = <Self::Target as Future<C>>::Error>`

`type Target: Future<C, Ok = Self::Finalize>`

`fn unravel(self) -> Self::Target`

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 2]> + Fork<T> + Unpin> Unravel<C> for [T; 2] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 2]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0002Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 3]> + Fork<T> + Unpin> Unravel<C> for [T; 3] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 3]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0003Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 4]> + Fork<T> + Unpin> Unravel<C> for [T; 4] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 4]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0004Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 5]> + Fork<T> + Unpin> Unravel<C> for [T; 5] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 5]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0005Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 6]> + Fork<T> + Unpin> Unravel<C> for [T; 6] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 6]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0006Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 7]> + Fork<T> + Unpin> Unravel<C> for [T; 7] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 7]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0007Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 8]> + Fork<T> + Unpin> Unravel<C> for [T; 8] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 8]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0008Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 9]> + Fork<T> + Unpin> Unravel<C> for [T; 9] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 9]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0009Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 10]> + Fork<T> + Unpin> Unravel<C> for [T; 10] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 10]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0010Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 11]> + Fork<T> + Unpin> Unravel<C> for [T; 11] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 11]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0011Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 12]> + Fork<T> + Unpin> Unravel<C> for [T; 12] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 12]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0012Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 13]> + Fork<T> + Unpin> Unravel<C> for [T; 13] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 13]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0013Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 14]> + Fork<T> + Unpin> Unravel<C> for [T; 14] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 14]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0014Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 15]> + Fork<T> + Unpin> Unravel<C> for [T; 15] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 15]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0015Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 16]> + Fork<T> + Unpin> Unravel<C> for [T; 16] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 16]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0016Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 17]> + Fork<T> + Unpin> Unravel<C> for [T; 17] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 17]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0017Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 18]> + Fork<T> + Unpin> Unravel<C> for [T; 18] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 18]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0018Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 19]> + Fork<T> + Unpin> Unravel<C> for [T; 19] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 19]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0019Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 20]> + Fork<T> + Unpin> Unravel<C> for [T; 20] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]

`type Finalize = MapErr<ArrayFinalize<C, T, [C::Finalize; 20]>, fn(_: <C::Finalize as Future<C>>::Error) -> ArrayUnravelError<C::Error, <C::Future as Future<C>>::Error, <C::Target as Future<C>>::Error, <C::Finalize as Future<C>>::Error>>`

`type Target = Array0020Unravel<T, C>`

`fn unravel(self) -> Self::Target`[src]

`impl<T, C: ?Sized + Write<[<C as Dispatch<T>>::Handle; 21]> + Fork<T> + Unpin> Unravel<C> for [T; 21] where T: Unpin, C::Target: Unpin, C::Handle: Unpin, C::Finalize: Unpin, C::Future: Unpin,` [src]